home *** CD-ROM | disk | FTP | other *** search
/ One Click 14 / OneClick14.iso / Ferramentas / Convert XLS to Pdf / xls2pdf_setup.exe / {app} / lib / gs_ttf.ps < prev    next >
Encoding:
Text File  |  2002-10-04  |  33.0 KB  |  1,104 lines
  1. %    Copyright (C) 1996, 2000 Aladdin Enterprises.  All rights reserved.
  2. % 
  3. % This software is provided AS-IS with no warranty, either express or
  4. % implied.
  5. % 
  6. % This software is distributed under license and may not be copied,
  7. % modified or distributed except as expressly authorized under the terms
  8. % of the license contained in the file LICENSE in this distribution.
  9. % 
  10. % For more information about licensing, please refer to
  11. % http://www.ghostscript.com/licensing/. For information on
  12. % commercial licensing, go to http://www.artifex.com/licensing/ or
  13. % contact Artifex Software, Inc., 101 Lucas Valley Road #110,
  14. % San Rafael, CA  94903, U.S.A., +1(415)492-9861.
  15.  
  16. % $Id: gs_ttf.ps,v 1.21 2002/10/03 19:40:27 igor Exp $
  17. % Support code for direct use of TrueType fonts.
  18. % (Not needed for Type 42 fonts.)
  19.  
  20. % Note that if you want to use this file without including the ttfont.dev
  21. % option when you built Ghostscript, you will need to load the following
  22. % files before this one:
  23. %    lib/gs_mgl_e.ps
  24. %    lib/gs_mro_e.ps
  25. %    lib/gs_wan_e.ps
  26.  
  27. % Thanks to B. Jackowski and GUST (the Polish TeX Users' Group) for
  28. % the glyf-splitting code.
  29.  
  30. % ---------------- Font loading machinery ---------------- %
  31.  
  32. % Augment the FONTPATH machinery so it recognizes TrueType fonts.
  33.  
  34. /.scanfontheaders where {
  35.   pop /.scanfontheaders [
  36.    .scanfontheaders aload pop (\000\001\000\000*) (true*)
  37.   ] def
  38. } if
  39.  
  40. % <file> <key> .findfontvalue <value> true
  41. % <file> <key> .findfontvalue false
  42. % Closes the file in either case.
  43. /.findnonttfontvalue /.findfontvalue load def
  44. /.findfontvalue {
  45.   1 index read pop 2 index 1 index unread
  46.   dup 0 eq exch (t) 0 get eq or {
  47.         % If this is a font at all, it's a TrueType font.
  48.     dup /FontType eq {
  49.       pop closefile 42 true
  50.     } {
  51.       dup /FontName eq { pop .findttfontname } { pop closefile false } ifelse
  52.     } ifelse
  53.   } {
  54.         % Not a TrueType font.
  55.     .findnonttfontvalue
  56.   } ifelse
  57. } bind def
  58.  
  59. % <file> .findttfontname <fname> true
  60. % <file> .findttfontname false
  61. % Closes the file in either case.
  62. /.findttfontname {
  63.   .loadttfonttables
  64.   tabdict /name .knownget {
  65.     dup 8 getu32 f exch setfileposition
  66.     12 getu32 string f exch readstring pop
  67.     6 findname
  68.   } {
  69.     false
  70.   } ifelse
  71.   f closefile end end
  72. } bind def
  73.  
  74. % Load a font file that might be a TrueType font.
  75.  
  76. % <file> .loadfontfile -
  77. /.loadnonttfontfile /.loadfontfile load def
  78. /.loadfontfile {
  79.   dup read pop 2 copy unread 0 eq {
  80.         % If this is a font at all, it's a TrueType font.
  81.     .loadttfont pop
  82.   } {
  83.         % Not a TrueType font.
  84.     .loadnonttfontfile
  85.   } ifelse
  86. } bind def
  87.  
  88. % ---------------- Automatic Type 42 generation ---------------- %
  89.  
  90. % Load a TrueType font from a file as a Type 42 PostScript font.
  91. % The thing that makes this really messy is the handling of encodings.
  92. % There are 2 interacting tables that affect the encoding:
  93. %       'cmap' provides multiple maps from character codes to glyph indices
  94. %       'post' maps glyph indices to glyph names (if present)
  95. % What we need to get out of this is:
  96. %       Encoding mapping character codes to glyph names
  97. %         (the composition of cmap and post)
  98. %       CharStrings mapping glyph names to glyph indices
  99. %         (the inverse of post)
  100. % If the post table is missing, we have to take a guess based on the cmap
  101. % table.
  102.  
  103. /.loadttfontdict 50 dict dup begin
  104.  
  105. /orgXUID AladdinEnterprisesXUID def
  106. /maxstring 32000 def    % half the maximum length of a PostScript string,
  107.             % must be a multiple of 4 (for hmtx / loca / vmtx)
  108.  
  109. % Define the Macintosh standard mapping from characters to glyph indices.
  110. /MacRomanEncoding dup .findencoding def
  111. /MacGlyphEncoding dup .findencoding def
  112.  
  113. % Invert the MacRomanEncoding.
  114. /.romanmacdict 300 dict
  115. 0 1 MacRomanEncoding length 1 sub {
  116.   MacRomanEncoding 1 index get
  117.         % Stack: dict index charname
  118.   dup /.notdef ne {
  119.     exch 2 index 2 index .knownget {
  120.       dup type /arraytype eq {
  121.     [ exch aload pop counttomark 2 add -1 roll ]
  122.       } {
  123.     exch 2 array astore
  124.       } ifelse
  125.     } if 2 index 3 1 roll put
  126.   } {
  127.     pop pop
  128.   } ifelse
  129. } for def
  130.  
  131. % Define remapping for misnamed glyphs in TrueType 'post' tables.
  132. % There are probably a lot more than this!
  133. /postremap mark
  134.   /Cdot /Cdotaccent
  135.   /Edot /Edotaccent
  136.   /Eoverdot /Edotaccent
  137.   /Gdot /Gdotaccent
  138.   /Ldot /Ldotaccent
  139.   /Zdot /Zdotaccent
  140.   /cdot /cdotaccent 
  141.   /edot /edotaccent 
  142.   /eoverdot /edotaccent
  143.   /gdot /gdotaccent 
  144.   /ldot /ldotaccent
  145.   /zdot /zdotaccent 
  146. .dicttomark readonly def
  147.  
  148. % ---- Utilities ---- %
  149.  
  150. % Define a serial number for creating unique XUIDs for TrueType fonts.
  151. % We used to use the checkSumAdjustment value from the font, but this is
  152. % not reliable, since some fonts don't set it correctly.
  153. % Note that we must do this in a string to make it immune to save/restore.
  154. /xuidstring <80000000> def
  155. /curxuid {        % - curxuid <int>
  156.   0 xuidstring { exch 8 bitshift exch add } forall
  157. } bind def
  158. /nextxuid {        % - nextxuid -
  159.   3 -1 0 {
  160.     xuidstring 1 index 2 copy get dup 255 ne {
  161.       1 add put pop exit
  162.     } if pop 0 put pop
  163.   } for
  164. } bind def
  165.  
  166. % <string> <index> getu16 <integer>
  167. /getu16 {
  168.   2 copy get 8 bitshift 3 1 roll 1 add get add
  169. } bind def
  170.  
  171. % <string> <index> gets16 <integer>
  172. /gets16 {
  173.   getu16 16#8000 xor 16#8000 sub
  174. } bind def
  175.  
  176. % <string> <index> getu32 <integer>
  177. /getu32 {
  178.   2 copy getu16 16 bitshift 3 1 roll 2 add getu16 add
  179. } bind def
  180.  
  181. % <string> <index> gets32 <integer>
  182. /gets32 {
  183.   2 copy gets16 16 bitshift 3 1 roll 2 add getu16 add
  184. } bind def
  185.  
  186. % <string> <index> <integer> putu16 -
  187. /putu16 {
  188.   3 copy -8 bitshift put
  189.   exch 1 add exch 16#ff and put
  190. } bind def
  191.  
  192. % <string> <index> <integer> putu32 -
  193. /putu32 {
  194.   3 copy -16 bitshift putu16
  195.   exch 2 add exch 16#ffff and putu16
  196. } bind def
  197.  
  198. % <nametable> <nameid> findname <string> true
  199. % <nametable> <nameid> findname false
  200. /findname {
  201.   DEBUG { (findname: ) print dup =only  } if
  202.   false 3 1 roll 0 1 3 index 2 getu16 1 sub {
  203.         % Stack: false table id index
  204.     12 mul 6 add 2 index exch 12 getinterval
  205.     dup 6 getu16 2 index eq {
  206.         % We found the name we want.
  207.       exch pop
  208.         % Stack: false table record
  209.       dup 10 getu16 2 index 4 getu16 add
  210.       1 index 8 getu16 4 -1 roll 3 1 roll getinterval exch
  211.         % Stack: false string record
  212.         % Check for 8- vs. 16-bit characters.
  213.       is2byte { string2to1 } if true null 4 -1 roll exit
  214.     } if pop
  215.   } for pop pop
  216.   DEBUG {
  217.     dup { ( = ) print 1 index == } { ( not found) = } ifelse
  218.   } if
  219. } bind def
  220.  
  221. % <namerecord> is2byte <bool>
  222. /is2byte {
  223.   dup 0 getu16 {
  224.     { pop true }        % Apple Unicode
  225.     { pop false }        % Macintosh Script manager
  226.     { 1 getu16 1 eq }        % ISO
  227.     { 1 getu16 1 eq }        % Microsoft
  228.   } exch get exec
  229. } bind def
  230.  
  231. % <string2> string2to1 <string>
  232. /string2to1 {
  233.   dup length 2 idiv string dup
  234.   0 1 3 index length 1 sub {
  235.     3 index 1 index 2 mul 1 add get put dup
  236.   } for pop exch pop
  237. } bind def
  238.  
  239. % Each procedure in this dictionary is called as follows:
  240. %       <encodingtable> proc <glypharray>
  241. /cmapformats mark
  242.   0 {        % Apple standard 1-to-1 mapping.
  243.     6 256 getinterval { } forall 256 packedarray
  244.   } bind
  245.   2 {        % Apple 16bit CJK (ShiftJIS etc)
  246.  
  247.     % /sHK_sz        subHeaderKey_size    % 1 * uint16
  248.     % /sH_sz        subHeader_size        % 4 * uint16
  249.     % /sH_len        subHeader_length
  250.     % /cmapf2_tblen    total table length
  251.     % /cmapf2_lang    language code (not used)
  252.     % /sHKs        subHeaderKeys
  253.  
  254.     /sHK_sz 2 def
  255.     /sH_sz 8 def
  256.     dup 2 getu16 /cmapf2_tblen exch def
  257.  
  258.     dup 4 getu16 /cmapf2_lang exch def
  259.  
  260.     dup 6 256 sHK_sz mul getinterval /sHKs exch def
  261.  
  262.     0        % initialization value for /sH_len
  263.     0 1 255 {
  264.        sHKs exch
  265.        2 mul getu16
  266.        1 index    % get current max
  267.        1 index    % get current subHeaderKey
  268.        lt {exch} if pop
  269.     } for
  270.     /sH_len exch def
  271.  
  272.     dup 6 256 sHK_sz mul add
  273.     cmapf2_tblen 1 index sub getinterval
  274.     /sH_gIA exch def
  275.  
  276.     /cmapf2_glyph_array 65535 array def
  277.  
  278.     /.cmapf2_putGID {
  279.         /cmapf2_ch cmapf2_ch_hi 8 bitshift cmapf2_ch_lo add def
  280.         firstCode cmapf2_ch_lo le
  281.         cmapf2_ch_lo firstCode entryCount add lt
  282.         and { % true: j is inside
  283.             sH_offset idRangeOffset add        % offset to gI
  284.             cmapf2_ch_lo firstCode sub 2 mul    % rel. pos. in range
  285.             add 6 add                % offset in sH_gIA
  286.             sH_gIA exch getu16
  287.             dup 0 gt { %
  288.                 idDelta add
  289.                 cmapf2_glyph_array exch cmapf2_ch exch put
  290.             } {
  291.                 pop
  292.                 % cmapf2_glyph_array cmapf2_ch 0 put
  293.             } ifelse
  294.         } {   % false: j is outside
  295.             % cmapf2_glyph_array cmapf2_ch 0 put
  296.         } ifelse
  297.     } def
  298.  
  299.     16#00 1 16#ff { % hi_byte scan
  300.         /cmapf2_ch_hi exch def
  301.         sHKs cmapf2_ch_hi sHK_sz mul getu16
  302.         /sH_offset exch def
  303.         sH_gIA sH_offset sH_sz getinterval
  304.             dup 0 getu16 /firstCode exch def
  305.             dup 2 getu16 /entryCount exch def
  306.             dup 4 gets16 /idDelta exch def
  307.             dup 6 getu16 /idRangeOffset exch def
  308.         pop
  309.         sH_offset 0 eq {
  310.            /cmapf2_ch_lo cmapf2_ch_hi def
  311.            /cmapf2_ch_hi 0 def
  312.            .cmapf2_putGID
  313.         } {
  314.            16#00 1 16#ff { % lo_byte scan
  315.                /cmapf2_ch_lo exch def
  316.                .cmapf2_putGID
  317.            } for
  318.         } ifelse
  319.      } for
  320.      pop
  321.      0 1 cmapf2_glyph_array length 1 sub { % rewrite null -> 0.
  322.         dup cmapf2_glyph_array exch get
  323.         null eq { cmapf2_glyph_array exch 0 put } {pop} ifelse
  324.      } for
  325.      cmapf2_glyph_array
  326.   } bind
  327.   4 {        % Microsoft/Adobe segmented mapping.
  328.     /etab exch def
  329.     /nseg2 etab 6 getu16 def
  330.     14 /endc etab 2 index nseg2 getinterval def
  331.         % The Apple TrueType documentation omits the 2-byte
  332.         % 'reserved pad' that follows the endCount vector!
  333.     2 add
  334.     nseg2 add /startc etab 2 index nseg2 getinterval def
  335.     nseg2 add /iddelta etab 2 index nseg2 getinterval def
  336.     nseg2 add /idroff etab 2 index nseg2 getinterval def
  337.         % The following hack allows us to properly handle
  338.         % idiosyncratic fonts that start at 0xf000:
  339.     pop
  340.     /firstcode startc 0 getu16 16#ff00 and dup 16#f000 ne { pop 0 } if def
  341.     /putglyph {
  342.       glyphs code 3 -1 roll put /code code 1 add def
  343.     } bind def
  344.         % Do a first pass to compute the size of the glyphs array.
  345.     /numcodes 0 def /glyphs 0 0 2 nseg2 3 sub {
  346.         % Stack: /glyphs numglyphs i2
  347.       /i2 exch def
  348.       /scode startc i2 getu16 def
  349.       /ecode endc i2 getu16 def
  350.       numcodes scode firstcode sub
  351.         % Hack for fonts that have only 0x0000 and 0xf000 ranges
  352.       %dup 16#e000 ge { 255 and } if
  353.       % the previous line is obstructive to CJK fonts, so it was removed
  354.       exch sub 0 .max ecode scode sub 1 add add
  355.       exch 1 index add exch
  356.       numcodes add /numcodes exch def
  357.     } for array def
  358.         % Now fill in the array.
  359.     /numcodes 0 def /code 0 def
  360.     0 2 nseg2 3 sub {
  361.       /i2 exch def
  362.       /scode startc i2 getu16 def
  363.       /ecode endc i2 getu16 def
  364.       numcodes scode firstcode sub
  365.         % Hack for fonts that have only 0x0000 and 0xf000 ranges
  366.       %dup 16#e000 ge { 255 and } if
  367.       % the previous line is obstructive to CJK fonts, so it was removed
  368.       exch sub 0 .max dup { 0 putglyph } repeat
  369.       ecode scode sub 1 add add numcodes add /numcodes exch def
  370.       /delta iddelta i2 gets16 def
  371.       DEBUG {
  372.     (scode=) print scode =only
  373.     ( ecode=) print ecode =only
  374.     ( delta=) print delta =only
  375.     ( droff=) print idroff i2 getu16 =
  376.       } if
  377.       idroff i2 getu16 dup 0 eq {
  378.     pop scode delta add 65535 and 1 ecode delta add 65535 and
  379.     { putglyph } for
  380.       } {    % The +2 is for the 'reserved pad'.
  381.         /gloff exch 14 nseg2 3 mul add 2 add i2 add add def
  382.         0 1 ecode scode sub {
  383.       2 mul gloff add etab exch getu16
  384.       dup 0 ne { delta add 65535 and } if putglyph
  385.     } for
  386.       } ifelse
  387.     } for glyphs /glyphs null def    % for GC
  388.   } bind
  389.   6 {        % Single interval lookup.
  390.     dup 6 getu16 /firstcode exch def dup 8 getu16 /ng exch def
  391.     firstcode ng add array
  392.         % Stack: tab array
  393.         % Fill elements 0 .. firstcode-1 with 0
  394.     0 1 firstcode 1 sub { 2 copy 0 put pop } for
  395.     dup firstcode ng getinterval
  396.         % Stack: tab array subarray
  397.         % Fill elements firstcode .. firstcode+nvalue-1 with glyph values
  398.     0 1 ng 1 sub {
  399.       dup 2 mul 10 add 4 index exch getu16 3 copy put pop pop
  400.     } for pop exch pop
  401.   } bind
  402. .dicttomark readonly def                % cmapformats
  403.  
  404. % <cmaptab> cmaparray <glypharray>
  405. /cmaparray {
  406.   dup 0 getu16 cmapformats exch .knownget {
  407.     DEBUG {
  408.       (cmap: format ) print 1 index 0 getu16 = flush
  409.     } if exec
  410.   } {
  411.     (Can't handle format ) print 0 getu16 = flush
  412.     0 1 255 { } for 256 packedarray
  413.   } ifelse
  414.   DEBUG {
  415.     (cmap: length=) print dup length = dup ==
  416.   } if
  417. } bind def
  418.  
  419. % Each procedure in this dictionary is called as follows:
  420. %       posttable <<proc>> glyphencoding
  421. /postformats mark
  422.   16#00010000  {    % 258 standard Macintosh glyphs.
  423.     pop MacGlyphEncoding
  424.   }
  425.   16#00020000  {    % Detailed map, required by Microsoft fonts.
  426.     dup length 36 lt {
  427.       DEBUG { (post format 2.0 invalid.) = flush } if
  428.       pop [ ]
  429.     } {
  430.     /postglyphs exch def
  431.       postglyphs 32 getu16 /numglyphs exch def
  432.       /glyphnames numglyphs 2 mul 34 add def
  433.       [ 0 1 numglyphs 1 sub {
  434.     2 mul 34 add postglyphs exch getu16
  435.     dup 258 lt {
  436.       MacGlyphEncoding exch get
  437.     } {
  438.       dup 32768 ge {
  439.         % According to the published TrueType spec, such values are
  440.         % "reserved for future use", but at least some PDF files
  441.         % produced by the Adobe PDF library contain entries with a
  442.         % value of 16#ffff.
  443.         pop /.notdef
  444.       } {
  445.         258 sub glyphnames exch {
  446.           postglyphs 1 index get 1 add add
  447.         } repeat
  448.         1 add postglyphs exch 2 copy 1 sub get getinterval cvn
  449.         % At least some of Microsoft's TrueType fonts use incorrect
  450.         % (Adobe-incompatible) names for some glyphs.
  451.         % Correct for this here.
  452.         postremap 1 index .knownget { exch pop } if
  453.       } ifelse
  454.     } ifelse
  455.       } for ]
  456.     }
  457.     ifelse
  458.   } bind
  459.   16#00030000  {    % No map.
  460.     pop [ ]
  461.   } bind
  462. .dicttomark readonly def                % postformats
  463.  
  464. % Each procedure in this dictionary is called as follows:
  465. %    <file> <length> -proc- <string|array_of_strings>
  466. % Note that each table must have an even length, because of a strange
  467. % Adobe requirement that each sfnts entry have even length.
  468. /readtables mark
  469.     % Ordinary tables
  470.   (cmap) { .readtable }
  471.   (head) 1 index
  472.   (hhea) 1 index
  473.   (maxp) 1 index
  474.   (name) 1 index
  475.   (OS/2) 1 index
  476.   (post) 1 index
  477.   (vhea) 1 index
  478.     % Big tables
  479.   (glyf) { .readbigtable }
  480.   (loca) 1 index
  481.   (hmtx) 1 index
  482.   (vmtx) 1 index
  483.     % Tables only needed for embedding in PDF files
  484.   (cvt ) { .readtable }
  485.   (fpgm) 1 index
  486.   (prep) 1 index
  487. .dicttomark
  488. % Normally there would be a 'readonly' here, but the ttf2pf utility wants
  489. % to include the 'kern' table as well, so we leave the readtables dictionary
  490. % writable.
  491. def                % readtables
  492.  
  493. % Read a table as a single string.
  494. % <file> <length> .readtable <string>
  495. /.readtable {
  496.   dup dup 1 and add string
  497.         % Stack: f len str
  498.   dup 0 4 -1 roll getinterval
  499.         % Stack: f str str1
  500.     % Because of the absurd PostScript specification that gives an
  501.     % error for reading into an empty string, we have to check for
  502.     % this explicitly here.
  503.   3 -1 roll exch
  504.   dup () ne { readstring } if pop pop
  505. } bind def
  506.  
  507. % Read a big table (one that may exceed 64K).
  508. % <file> <length> .readbigtable <string[s]>
  509. /.readbigtable {
  510.   dup 65400 lt {
  511.     .readtable
  512.   } {
  513.     currentuserparams /VMReclaim get -2 vmreclaim
  514.     [ 4 2 roll {
  515.         % Stack: mark ... f left
  516.       dup maxstring le { exit } if
  517.       1 index maxstring string readstring pop 3 1 roll maxstring sub
  518.     } loop .readtable ]
  519.     exch vmreclaim
  520.   } ifelse
  521. } bind def
  522.  
  523. end readonly def                % .loadttfontdict
  524.  
  525. % <tab> .printtab -
  526. /.printtab {
  527.   dup 0 4 getinterval print ( ) print
  528.   dup 8 getu32 =only ( ) print
  529.   12 getu32 =
  530. } bind def
  531.  
  532. % <file> .loadttfonttables -
  533. % Pushes .loadttfontdict & scratch dict on d-stack.
  534. % Defines f, offsets, tables, tabdict, tabs.
  535. /.loadttfonttables {
  536.   .loadttfontdict begin
  537.   40 dict begin
  538.   /f exch def
  539.   /offsets f 12 string readstring pop def
  540.   /tables f offsets 4 getu16 16 mul string readstring pop def
  541.   /tabdict tables length 16 idiv dict def
  542.     % tabs = tables we want to keep, sorted by file position.
  543.   /tabs [ 0 16 tables length 1 sub {
  544.     tables exch 16 getinterval
  545.     DEBUG { dup .printtab } if
  546.     dup 0 4 getinterval readtables 1 index known {
  547.       tabdict exch 2 index put
  548.     } {
  549.       pop pop
  550.     } ifelse
  551.   } for ] {
  552.     exch 8 getu32 exch 8 getu32 lt
  553.   } .sort def
  554.     % In certain malformed TrueType fonts, tables overlap.
  555.     % Truncate tables if necessary.
  556.   0 1 tabs length 2 sub {
  557.     dup tabs exch get exch 1 add tabs exch get
  558.     1 index 8 getu32 2 index 12 getu32 add
  559.     1 index 8 getu32 gt {
  560.       (**** Warning: ) print 1 index 0 4 getinterval print
  561.       ( overlaps ) print dup 0 4 getinterval print
  562.       (, truncating.) = flush
  563.       dup 8 getu32 2 index 8 getu32 sub
  564.       2 index 12 3 -1 roll putu32
  565.     } if pop pop
  566.   } for
  567. } bind def
  568.  
  569. % - .readttdata -
  570. % Read data.  Updates offsets, tabs; stores data in tabdict.
  571. /.readttdata {
  572.   /fpos offsets length tables length add def
  573.   /sfpos offsets length tabs length 16 mul add def
  574.   offsets 4 tabs length putu16
  575.   tabs {
  576.     dup 0 4 getinterval /tname exch def
  577.     dup 8 getu32 /tpos exch def
  578.     dup 12 getu32 /tlen exch def
  579.     8 sfpos putu32
  580.     % Skip data between the end of the previous table and
  581.     % the beginning of this one, if any.
  582.     tpos fpos gt {
  583.       f tpos fpos sub () /SubFileDecode filter dup flushfile closefile
  584.       /fpos tpos def
  585.     } if
  586.     f tlen readtables tname get exec
  587.     tabdict tname 3 -1 roll put
  588.     /fpos fpos tlen add def
  589.     % Round up the table length to an even value.
  590.     /sfpos sfpos tlen dup 1 and add add def
  591.   } forall
  592. } bind def
  593.  
  594. % Find the string in a list of strings that includes a given index.
  595. % <strings> <index> .findseg <string> <index'>
  596. /.findseg {
  597.   exch {
  598.     dup length 2 index gt { exch exit } if
  599.     length sub
  600.   } forall
  601. } bind def
  602.  
  603. % - .makesfnts -
  604. % Defines checksum, getloca, head, locatable, numloca, post, sfnts, upem
  605. /.makesfnts {
  606.   .readttdata
  607.   /head tabdict /head get def
  608.   /locatable tabdict /loca get def
  609.   /post tabdict /post .knownget not { null } if def
  610.   /numloca
  611.     locatable dup type /stringtype eq
  612.      { length }
  613.      { 0 exch { length add } forall }
  614.     ifelse    % no def yet
  615.   locatable type /stringtype eq {
  616.     /.indexloca {} def
  617.   } {
  618.     /.indexloca /.findseg load def
  619.   } ifelse
  620.   head 50 getu16 0 ne {
  621.     /getloca {
  622.       2 bitshift locatable exch .indexloca getu32
  623.     } def
  624.     4 idiv 1 sub
  625.   } {
  626.     /getloca {
  627.       dup add locatable exch .indexloca getu16 dup add
  628.     } def
  629.     2 idiv 1 sub
  630.   } ifelse def        % numloca
  631.     % If necessary, re-partition the glyfs.
  632.   tabdict /glyf get dup type /stringtype ne {
  633.     .dividesfnts tabdict /glyf 3 -1 roll put
  634.   } {
  635.     pop
  636.   } ifelse
  637.   /sfnts [
  638.     offsets tabs { concatstrings } forall
  639.     tabs {
  640.       0 4 getinterval tabdict exch get
  641.       dup type /stringtype ne { aload pop } if
  642.     } forall
  643.   ] def
  644. } bind def
  645.  
  646. % <glyfs> .dividesfnts <glyfs'>
  647. /.dividesfnts {
  648.   /glyfs exch def
  649.   /len1 0 glyfs { length add } forall def
  650.         % Determine where to split the glyfs by scanning loca.
  651.         % The very last entry in loca may be bogus.
  652.         % Note that some loca entries may be odd, but we can only
  653.         % split at even positions.
  654.         %
  655.         % Construct splitarray, the array of final lengths of
  656.         % the sfnts entries covering the glyfs (i.e., all but
  657.         % the first and last sfnts entries).
  658.     /prevsplit 0 def
  659.     /prevboundary 0 def
  660.     /splitarray [
  661.       0 1 numloca 1 sub {
  662.     getloca dup prevsplit maxstring add gt {
  663.       prevboundary prevsplit sub exch
  664.       /prevsplit prevboundary def
  665.     } if
  666.     dup 1 and 0 eq { /prevboundary exch def } { pop } ifelse
  667.       } for
  668.       len1 prevsplit sub
  669.     ] def
  670.     currentuserparams /VMReclaim get -2 vmreclaim
  671.     [
  672.         % Re-split the sfnts glyfs strings according to splitarray.
  673.         % We do this by iterating over the final segments defined
  674.         % by splitarray, and constructing them from pieces of the
  675.         % current glyfs strings.  We recycle the current strings
  676.         % when possible, to avoid stressing the allocator.
  677.       /sfnt_idx 0 def
  678.       /strpos 0 def
  679.       /avail () def
  680.       splitarray {
  681.     /seglen exch def
  682.     /segpos 0 def
  683.     avail length seglen ge
  684.       { avail 0 seglen getinterval /avail () def } { seglen string }
  685.     ifelse
  686.     {
  687.       /str glyfs sfnt_idx get def
  688.       /strlen str length def
  689.       /strleft strlen strpos sub def
  690.       seglen segpos sub strleft lt { exit } if
  691.         % Copy the (rest of the) string into the new segment.
  692.         % We know strleft <= segleft.
  693.       dup segpos str strpos strleft getinterval putinterval
  694.       /segpos segpos strleft add def
  695.       /avail str def
  696.       /sfnt_idx sfnt_idx 1 add def
  697.       /strpos 0 def
  698.       segpos seglen eq { exit } if
  699.     } loop
  700.         % Fill up the segment with an initial piece of the next
  701.         % existing glyfs string.  We know strleft > segleft.
  702.     /segleft seglen segpos sub def
  703.     dup segpos str strpos segleft getinterval putinterval
  704.     /strpos strpos segleft add def
  705.       } forall
  706.     ]
  707.     exch vmreclaim
  708. } bind def
  709.  
  710. % - .getpost -
  711. % Uses post, defines glyphencoding
  712. /.getpost {
  713.   /glyphencoding post null eq {
  714.     DEBUG { (post missing) = flush } if [ ]
  715.   } {
  716.     postformats post 0 getu32 .knownget {
  717.       DEBUG {
  718.     (post: format ) print
  719.     post 0 getu16 =only (,) print post 2 getu16 = flush
  720.       } if
  721.       post exch exec
  722.     } {
  723.       DEBUG { (post: unknown format ) print post 0 getu32 = flush } if [ ]
  724.     } ifelse
  725.   } ifelse def
  726. } bind def
  727.  
  728. % - .ttkeys <key> <value> ...
  729. /.ttkeys {
  730.   count /ttkeycount exch def
  731.   /upem head 18 getu16 def
  732.   /FontMatrix matrix
  733.   /FontBBox [ 36 2 42 { head exch gets16 upem div } for ]
  734.   nextxuid
  735.   tabdict /name .knownget {
  736.         % Find the names from the 'name' table.
  737.     /names exch def
  738.     /FontName names 6 findname not { curxuid 16 8 string cvrs } if
  739.       /fontname 1 index def
  740.     /FontInfo mark
  741.       names 0 findname { /Notice exch } if
  742.       names 1 findname { /FamilyName exch } if
  743.       names 4 findname { /FullName exch } if
  744.       names 5 findname { /Version exch } if
  745.   } {
  746.         % No name table, fabricate a FontName.
  747.     /FontName curxuid 16 8 string cvrs
  748.       /fontname 1 index def
  749.     /FontInfo mark
  750.   } ifelse
  751.         % Stack: ... /FontInfo mark key1 value1 ...
  752.   post null ne {
  753.     /ItalicAngle post 4 gets32 65536.0 div
  754.     /isFixedPitch post 12 getu32 0 ne
  755.     /UnderlinePosition post 8 gets16 upem div
  756.     /UnderlineThickness post 10 gets16 upem div
  757.   } if
  758.   counttomark 0 ne { .dicttomark } { pop pop } ifelse
  759.   /XUID [orgXUID 42 curxuid]
  760.   DEBUG {
  761.     tabs { .printtab } forall
  762.     [ sfnts { length } forall ] ==
  763.     count ttkeycount sub array astore dup { == } forall aload pop
  764.   } if
  765.   /sfnts sfnts
  766. } bind def
  767.  
  768. % ---------------- Standard TrueType font loading ---------------- %
  769.  
  770. % - .pickcmap -
  771. % Defines cmapsub, cmaptab
  772. /.pickcmap {
  773.   tabdict /cmap get
  774.         % The Apple cmap format is no help in determining the encoding.
  775.         % Look for a Microsoft table.  If we can't find one,
  776.         % just use the first table, whatever it is.
  777.   dup 4 8 getinterval exch             % the default
  778.   0 1 2 index 2 getu16 1 sub {
  779.     8 mul 4 add 1 index exch 8 getinterval
  780.     DEBUG {
  781.       (cmap: platform ) print dup 0 getu16 =only
  782.       ( encoding ) print dup 2 getu16 = flush
  783.     } if
  784.     dup 0 getu16 3 eq { exch 3 -1 roll pop exit } if pop
  785.   } for
  786.         % Stack: subentry table
  787.   /cmapsub 2 index def
  788.   exch 4 getu32 1 index length 1 index sub getinterval
  789.   /cmaptab exch def
  790. } bind def
  791.  
  792. % <glyph> .nname <_name>
  793. /.nname {
  794.   =string cvs (_) exch concatstrings cvn
  795. } bind def
  796.  
  797. % - .charkeys /CharStrings <charstrings> /Encoding <encoding>
  798. % Resets glyphencoding
  799. /.charkeys {
  800.   DEBUG {
  801.     (glyphencoding: length=) print glyphencoding dup length = === flush
  802.   } if
  803.         % Hack: if there is no usable post table but the cmap uses
  804.         % the Microsoft Unicode encoding, use ISOLatin1Encoding.
  805.   glyphencoding length 0 eq cmapsub 0 4 getinterval <00030001> eq and {
  806.     /glyphencoding ISOLatin1Encoding dup length array copy def
  807.   } if
  808.         % If necessary, fabricate additional glyphencoding entries
  809.         % to cover all of loca, or truncate glyphencoding.
  810.   glyphencoding length numloca lt {
  811.     /glyphencoding numloca array
  812.       glyphencoding length dup 1 sub 0 1 3 2 roll {
  813.         dup glyphencoding exch get
  814.         3 index 3 1 roll put
  815.       } for
  816.       % /glyphencoding <newarray> <glyphencoding length>
  817.       1 numloca 1 sub {
  818.         1 index exch dup .nname put
  819.       } for
  820.     def
  821.   } {
  822.     /glyphencoding glyphencoding 0 numloca getinterval def
  823.   } ifelse
  824.         % Some badly designed Chinese fonts have a post table
  825.         % in which all glyphs other than 0 are named .null.
  826.         % Use CharStrings to keep track of the reverse map from
  827.         % names to glyphs, and don't let any name be used for
  828.         % more than one glyph.
  829.   /CharStrings glyphencoding dup length 1 add dict    % +1 for .notdef
  830.     0 1 3 index length 1 sub {
  831.         % Stack: glyphencoding dict index
  832.       2 index 1 index get 2 index 1 index known {
  833.         % The same name maps to more than one glyph.
  834.         % Change the name.
  835.     pop dup .nname 3 index 2 index 2 index put
  836.       } if
  837.       2 index exch 3 -1 roll put
  838.     } for exch pop
  839.         % If there is no .notdef entry, map it to glyph 0.
  840.   dup /.notdef known not { dup /.notdef 0 put } if
  841.   readonly
  842.   /Encoding
  843.     [ cmaptab cmaparray dup length 256 gt { 0 256 getinterval } if
  844.     { glyphencoding exch get } forall
  845.     counttomark 256 exch sub { /.notdef } repeat ]
  846.   DEBUG { (Encoding: ) print dup === flush } if
  847. } bind def
  848.  
  849. % -mark- <key> <value> ... .definettfont <font>
  850. /.definettfont {
  851.   /FontType 42
  852.   /PaintType 0
  853.   DEBUG {
  854.     (numloca=) print numloca =
  855.   } if
  856.   .dicttomark
  857.   end end dup /FontName get exch definefont
  858. } bind def
  859.  
  860. % <file> .loadttfont <type42font>
  861. /.loadttfont {
  862.   .loadttfonttables
  863.   .makesfnts
  864.   .getpost
  865.   .pickcmap
  866.   mark
  867.   .charkeys
  868.   .ttkeys
  869.   .definettfont
  870. } bind def
  871.  
  872. % ---------------- CIDFontType 2 font loading ---------------- %
  873.  
  874. % Create a string with N CIDs from the top of the stack.
  875. % <cid1> ... <cidN> <N> .makecidmap <string>
  876. /.makecidmap {
  877.   dup 2 mul string dup 3 -1 roll 1 sub 2 mul -2 0 {
  878.         % Stack: cids str str i2
  879.     2 copy 5 index -8 bitshift put
  880.     1 add 4 -1 roll 16#ff and put dup
  881.   } for pop
  882. } bind def
  883.  
  884. % -mark- <key> <value> ... .definettcidfont <font>
  885. /.definettcidfont {
  886.   /CIDFontName fontname
  887.   /CIDFontType 2
  888.   /CIDSystemInfo mark
  889.     /Registry (Adobe)
  890.     /Ordering (Japan1)        % adhoc
  891.     /Supplement 0
  892.   .dicttomark
  893.   /CharStrings mark /.notdef 0 .dicttomark
  894.         % The cmap isn't of any use even if it is present.
  895.         % Just construct an identity CIDMap covering all the glyphs.
  896.   mark 0 1 numloca 1 sub { } for
  897.   counttomark /cidcount exch def
  898.   cidcount maxstring le {
  899.         % Use a single string.
  900.     cidcount .makecidmap exch pop
  901.   } {
  902.         % We must use 2 strings.
  903.     maxstring .makecidmap counttomark 1 add 1 roll
  904.     counttomark .makecidmap exch pop exch 2 array astore
  905.   } ifelse
  906.   /CIDMap exch
  907.   /CIDCount cidcount
  908.   /GDBytes 2
  909.   .dicttomark
  910.   end end dup /CIDFontName get exch /CIDFont defineresource
  911. } bind def
  912.  
  913. % <file> .loadttcidfont <cidtype2font>
  914. /.loadttcidfont {
  915.   .loadttfonttables
  916.   .makesfnts
  917.     % CIDFontType2 fonts don't have a cmap: they are indexed by CID.
  918.   mark
  919.   .ttkeys
  920.   .definettcidfont
  921. } bind def
  922.  
  923. % ---------------- PDF TrueType font loading ---------------- %
  924.  
  925. % Strictly speaking, this code should be loaded only if we have a PDF
  926. % interpreter, but it's so closely tied to the rest of the code in this
  927. % file that we always include it.
  928.  
  929. % <plat+enc> .findcmap <subtable> true
  930. % <plat+enc> .findcmap false
  931. /.findcmap {
  932.   false exch tabdict /cmap get
  933.         % Some fonts have multiple cmaps with the same platform and
  934.         % encoding.  Use the first one we find.
  935.   0 1 2 index 2 getu16 1 sub {
  936.         % Stack: false plat+enc cmap index
  937.     8 mul 4 add 1 index exch 8 getinterval 
  938.     dup 0 4 getinterval 3 index eq {
  939.       4 getu32 1 index exch 1 index length 1 index sub getinterval
  940.       4 -1 roll not 4 2 roll exit
  941.     } if pop
  942.   } for
  943.         % Stack: false plat+enc cmap || subtable true plat+enc cmap
  944.   pop pop
  945. } bind def
  946.  
  947. % Build .symbol_list for .pdfcharkeys .
  948. % It is a dictionary containing all SymbolEncoding glyph names
  949. % and random names for filling gaps in the character code range.
  950. /.symbol_list 256 dict def
  951. {
  952.   =string 0 (x) 0 get put
  953.   /SymbolEncoding .findencoding
  954.   0 1 255 {
  955.     dup 2 index exch get
  956.     dup /.notdef eq {
  957.       pop dup
  958.       =string 1 3 getinterval cvs length 1 add
  959.       =string exch 0 exch getinterval cvn
  960.     } if
  961.     exch //.symbol_list 3 1 roll put
  962.   } for
  963.   pop
  964. } bind exec
  965.  
  966. % Create .GS_extended_SymbolEncoding as inverse of .symbol_list .
  967. {
  968.   /.GS_extended_SymbolEncoding 256 array
  969.   //.symbol_list {
  970.     exch 2 index 3 1 roll put  
  971.   } forall
  972.   .defineencoding
  973. } bind exec
  974.  
  975. /.addglyph    % <name> <glyph#> .addglyph <name> <glyph#> 
  976.               % <name> <glyph#> .addglyph -
  977. {
  978.   dup cmapencoding length lt {
  979.     cmapencoding exch get dup 0 eq {
  980.       pop pop
  981.     } if
  982.   } {
  983.     pop pop
  984.   } ifelse
  985. } bind def
  986.  
  987. % <subcmap> <chartoglyphmap> .pdfmapchars
  988. %   /CharStrings <charstrings>
  989. /.pdfmapchars {
  990.   exch cmaparray /cmapencoding exch def
  991.   /CharStrings mark 
  992.  
  993.   % Add glyphs of <chartoglyphmap>*<subcmap> :
  994.   3 2 roll {
  995.     dup type /arraytype eq {
  996.       exch /.name exch def
  997.       { .name exch //.addglyph exec
  998.       } forall
  999.       currentdict /.name undef
  1000.     } {
  1001.       //.addglyph exec
  1002.     } ifelse
  1003.   } forall
  1004.  
  1005.         % stack: /CharStrings mark /name1 glyph#1 /name2 glyph#2 ... /namen glyph#n
  1006.         % Stack depth is restricted with AdobeGlyphList size.
  1007.  
  1008.   % Add glyphs of 'post' (with lower priority, see .dicttomark) :
  1009.   0 1 glyphencoding length 1 sub {
  1010.     dup glyphencoding exch get exch
  1011.     dup 0 eq {
  1012.       pop pop
  1013.     } if
  1014.   } for
  1015.  
  1016.   /.notdef 0
  1017.   .dicttomark
  1018. } bind def
  1019.  
  1020. % - .pdfcharkeys /CharStrings <charstrings> /Encoding <encoding>
  1021. /.pdfcharkeys {
  1022.     % The following algorithms are per the PDF Reference, Second Edition
  1023.     % (PDF 1.3 reference manual).
  1024.  
  1025.   is_symbolic {
  1026.     <00030001> .findcmap {
  1027.       %
  1028.       % Adobe PDF spec says that symbolic fonts should contain exactly one 
  1029.       % cmap subtable for Platform=1, Encoding=0.
  1030.       % Perhaps "Adobe Acrobat PDFWriter 4.0 for Windows" sometimes embeds
  1031.       % fonts with both subtables 3.1 and 1.0 (see comparefiles/159.pdf,
  1032.       % the font "Arial,Bold" with the character "registered"),
  1033.       % and both Acrobat Reader 4.0 and 5.0 choose 3.1.
  1034.       % Therefore we try 3.1 first.
  1035.       %
  1036.       (   **** Warning: Embedded symbolic TT fonts should not contain a cmap for Platform=3 Encoding=1.\n)
  1037.         pdfformaterror
  1038.       AdobeGlyphList .pdfmapchars 
  1039.       /Encoding /WinAnsiEncoding .findencoding
  1040.     } {
  1041.       %
  1042.       % Adobe PDF spec says that in this case PDF interpreter should
  1043.       % map character codes directly to glyphs using
  1044.       % the cmap <00010000>. But we use PS interpreter to emulate
  1045.       % a PDF interpreter. Therefore we need to construct
  1046.       % a type 42 font, which requires an Encoding and a Charstrings.
  1047.       % We construct them with symbol_list, which
  1048.       % includes all glyphs from SymbolEncoding and additional
  1049.       % random names for 1-to-1 mapping.
  1050.       %
  1051.       % A real TT font may use a different characters than
  1052.       % the Symbol charaster set. Perhaps our code
  1053.       % will give a correct printing, because glyph names are not
  1054.       % important for symbolic fonts in PDF.
  1055.       %
  1056.       <00010000> .findcmap {
  1057.         .symbol_list .pdfmapchars
  1058.         /Encoding /.GS_extended_SymbolEncoding .findencoding
  1059.       } {
  1060.         % This is illegal with PDF spec.
  1061.         (   **** Warning: Embedded symbolic TT fonts must contain a cmap for Platform=1 Encoding=0.\n)
  1062.           pdfformaterror
  1063.         % Try to map Unicode to SymbolEncoding
  1064.         <00030001> .findcmap {
  1065.           AdobeGlyphList .pdfmapchars
  1066.           /Encoding /SymbolEncoding .findencoding
  1067.         } {
  1068.           % Apply the default algorithm. Hopely it has 'post'.
  1069.           .charkeys
  1070.         } ifelse
  1071.       } ifelse
  1072.     } ifelse
  1073.   } {
  1074.     <00030001> .findcmap {
  1075.       AdobeGlyphList .pdfmapchars 
  1076.       /Encoding /WinAnsiEncoding .findencoding
  1077.         % WinAnsiEncoding is just a stub here. 
  1078.         % It will be replaced with one from font resource,
  1079.         % because PDF spec requires it.
  1080.     } {
  1081.       <00010000> .findcmap {
  1082.     .romanmacdict .pdfmapchars 
  1083.         /Encoding /MacRomanEncoding .findencoding
  1084.       } {
  1085.         % Apply the default algorithm for using the 'post'.
  1086.     .charkeys
  1087.       } ifelse
  1088.     } ifelse
  1089.   } ifelse
  1090. } bind def
  1091.  
  1092. % <file> <is_symbolic> .loadpdfttfont <type42font>
  1093. /.loadpdfttfont {
  1094.   /is_symbolic exch def
  1095.   .loadttfonttables
  1096.   .makesfnts
  1097.   .getpost
  1098.   .pickcmap
  1099.   mark
  1100.   .pdfcharkeys
  1101.   .ttkeys
  1102.   .definettfont
  1103. } bind def
  1104.